<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Polymorphie (Programmierung)</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Polymorphie_(Programmierung)"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Polymorphie_Programmierung rootpage-Polymorphie_Programmierung skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Polymorphie (Programmierung)</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><p><b>Polymorphie</b> oder <b>Polymorphismus</b> (<a href="Neugriechische_Sprache" title="Neugriechische Sprache">griechisch</a> für <i>Vielgestaltigkeit</i>) ist ein Konzept in der <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientierten Programmierung</a>, das ermöglicht, dass ein <a href="Bezeichner" title="Bezeichner">Bezeichner</a> abhängig von seiner Verwendung <a href="Objekt_(Programmierung)" title="Objekt (Programmierung)">Objekte</a> unterschiedlichen <a href="Datentyp" title="Datentyp">Datentyps</a> annimmt. In älteren <a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">typisierten</a> <a href="Programmiersprache" title="Programmiersprache">Programmiersprachen</a> wird dagegen jedem Namen und jedem Wert im <a href="Quelltext" title="Quelltext">Quelltext</a> eines <a href="Computerprogramm" title="Computerprogramm">Programms</a> höchstens ein Typ zugeordnet. Dies bezeichnet man als <i>Monomorphie</i>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Arten_der_Polymorphie">Arten der Polymorphie</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Polymorphie_überladener_Operatoren"><span id="Polymorphie_.C3.BCberladener_Operatoren"></span>Polymorphie überladener Operatoren</h3></div>
<p>Ein <a href="Bezeichner" title="Bezeichner">Bezeichner</a>, der für einen <a href="Operator_(Mathematik)" title="Operator (Mathematik)">Operator</a> steht (bspw. „+“, „−“), kann mehrmals mit anderer Bedeutung implementiert werden. Für jeden Kontext, in dem der Operator neu deklariert wurde, muss die Implementierung immer eindeutig sein.
</p>
<div class="mw-heading mw-heading3"><h3 id="Polymorphie_der_objektorientierten_Programmierung">Polymorphie der objektorientierten Programmierung</h3></div>
<p>Die Polymorphie der objektorientierten <a href="Programmierung" title="Programmierung">Programmierung</a> ist eine Eigenschaft, die immer im Zusammenhang mit <a href="Vererbung_(Programmierung)" title="Vererbung (Programmierung)">Vererbung</a> und <a href="Schnittstelle_(Objektorientierung)" title="Schnittstelle (Objektorientierung)">Schnittstellen</a> (Interfaces) auftritt. Eine Methode ist polymorph, wenn sie in verschiedenen Klassen die gleiche <a href="Signatur_(Programmierung)" title="Signatur (Programmierung)">Signatur</a> hat, jedoch erneut implementiert ist.
</p><p>Gibt es in einem Vererbungszweig einer Klassenhierarchie mehrere <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a> auf unterschiedlicher Hierarchieebene, jedoch mit gleicher <a href="Signatur_(Programmierung)" title="Signatur (Programmierung)">Signatur</a>, wird erst zur Laufzeit bestimmt, welche der Methoden für ein gegebenes Objekt verwendet wird (<a href="Dynamisches_Binden" class="mw-redirect" title="Dynamisches Binden">Dynamisches Binden</a>). Bei einer mehrstufigen Vererbung wird jene Methode verwendet, die direkt in der Objektklasse (d. h. jene <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klasse</a>, von der das <a href="Objekt_(Programmierung)" title="Objekt (Programmierung)">Objekt</a> ein Exemplar ist) definiert ist, oder jene, die im Vererbungszweig am weitesten „unten“ liegt (d. h. die Methode, die von der Vererbung her am nächsten ist).
</p><p>Moderne Konzepte kennen jedoch auch Polymorphie über Klassengrenzen hinaus. So erlaubt die <a href="Programmiersprache" title="Programmiersprache">Programmiersprache</a> <a href="Objective-C" title="Objective-C">Objective-C</a> die Polymorphie zwischen zwei gleichnamigen <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a>, die in verschiedenen <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klassen</a> erstmals definiert sind.
</p>
<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">// NSObject kennt nicht -doSomething</span>
<span class="k">@interface</span> <span class="nc">KlasseA</span> : <span class="bp">NSObject</span> <span class="p">{</span>
<span class="w"> </span><span class="err">…</span>
<span class="p">}</span>
<span class="p">-</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="nf">doSomething</span><span class="p">;</span>
<span class="k">@end</span>
<span class="k">@interface</span> <span class="nc">KlasseB</span> : <span class="bp">NSObject</span> <span class="p">{</span>
<span class="w"> </span><span class="err">…</span>
<span class="p">}</span>
<span class="p">-</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="nf">doSomething</span><span class="p">;</span>
<span class="k">@end</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">// irgendwo</span>
<span class="kt">id</span><span class="w"> </span><span class="n">object</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">…</span><span class="w"> </span><span class="c1">// Ein Objekt einer beliebigen Klasse</span>
<span class="p">[</span><span class="n">object</span><span class="w"> </span><span class="n">doSomething</span><span class="p">];</span><span class="w"> </span><span class="c1">// polymorph zwischen KlasseA und KlasseB</span>
</pre></div>
<p>Die Subklasse-vor-Basisklasse-Regel gilt auch hier: Wenn die KlasseB zur KlasseC abgeleitet wird, würde die entsprechende Methode der KlasseC ausgeführt.
</p>
<div class="mw-heading mw-heading3"><h3 id="Polymorphie_einer_Funktion_bzw._Prozedur">Polymorphie einer Funktion bzw. Prozedur</h3></div>
<p>Ist der Rückgabewert oder ein Argument einer <a href="Funktion_(Programmierung)" title="Funktion (Programmierung)">Funktion</a> polymorph, so heißt die Funktion polymorphe Funktion. Mit Hilfe polymorpher Funktionen kann die <a href="Generische_Programmierung" title="Generische Programmierung">Generizität</a> von <a href="Datenstruktur" title="Datenstruktur">Datenstrukturen</a> auch in <a href="Algorithmus" title="Algorithmus">Algorithmen</a> angewandt werden.<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Polymorphie_von_Datentypen_oder_Klassen">Polymorphie von Datentypen oder Klassen</h3></div>
<p>Wird für eigene <a href="Datentyp" title="Datentyp">Datentypen</a> bzw. <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klassen</a> bei der Instanziierung bzw. beim Konstruktoraufruf ein <a href="Parameter_(Informatik)" title="Parameter (Informatik)">Parameter</a> für den tatsächlich verwendeten <a href="Datentyp" title="Datentyp">Datentyp</a> übergeben, spricht man von <i>parametrischer Polymorphie</i>, welche semantisch mit <a href="Generische_Programmierung" title="Generische Programmierung">Generizität</a> übereinstimmt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Weitere_Unterteilungen">Weitere Unterteilungen</h2></div>
<p>Folgende weitere Unterteilung ist möglich:
</p>
<ul><li>universelle Polymorphie
<ul><li>parametrische Polymorphie</li>
<li>Inklusions-/Vererbungspolymorphie</li></ul></li>
<li>Ad-hoc-Polymorphie
<ul><li>Coercion</li>
<li>Überladung</li></ul></li></ul>
<p>Manchmal wird Ad-hoc-Polymorphie gleichgesetzt mit <a href="%C3%9Cberladen" title="Überladen">Überladen</a>. Das ist auf <a href="Christopher_Strachey" title="Christopher Strachey">Christopher Strachey</a> zurückzuführen,<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> der als Erster Polymorphie in parametrische und Ad-hoc-Polymorphie unterteilte.
</p><p>Luca Cardelli und Peter Wegner erweiterten Stracheys Konzept um die Inklusionspolymorphie,<sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> um Subtypen und Vererbung zu modellieren. Die obige Auflistung spiegelt also Stracheys Einteilung wider, erweitert um die Inklusionspolymorphie von Cardelli und Wegner.
</p>
<div class="mw-heading mw-heading3"><h3 id="Universelle_und_Ad-hoc-Polymorphie">Universelle und Ad-hoc-Polymorphie</h3></div>
<p>Universelle Polymorphie unterscheidet sich von Ad-hoc-Polymorphie in mehreren Aspekten. Bei Ad-hoc-Polymorphie kann der einem Namen zugeordnete Wert nur endlich vielen verschiedene Typen angehören. Diese sind zudem während der <a href="Kompilierung" class="mw-redirect" title="Kompilierung">Kompilierung</a> bekannt. Universelle Polymorphie dagegen erlaubt es, jedweden bekannten Typ zuzuordnen; auch solche, die vielleicht erst später definiert werden.
</p><p>Ein weiterer Unterschied liegt darin, dass die Implementierung einer universell-polymorphen Funktion generell den gleichen Code unabhängig von den Typen ihrer Argumente ausführt, während ad-hoc-polymorphe (also überladene) Funktionen abhängig von den Typen ihrer Argumente völlig unterschiedlich implementiert sein können.
</p>
<div class="mw-heading mw-heading3"><h3 id="Überladen_und_Coercion"><span id=".C3.9Cberladen_und_Coercion"></span>Überladen und Coercion</h3></div>
<p><a href="Funktion_(Programmierung)" title="Funktion (Programmierung)">Funktionen</a> sind <a href="%C3%9Cberladen" title="Überladen">überladen</a>, wenn unterschiedliches Verhalten mit demselben Namen verbunden ist. Dies gilt analog für Bezeichner von Operatoren: Beispielsweise ist der <a href="Operator_(Mathematik)" title="Operator (Mathematik)">Operator</a> + in vielen <a href="Programmiersprache" title="Programmiersprache">Programmiersprachen</a> von vornherein überladen. So können mit ihm sowohl ganze Zahlen als auch Gleitkommazahlen addiert werden. Oft wird er auch zur <a href="Konkatenation_(Wort)" class="mw-redirect" title="Konkatenation (Wort)">Stringkonkatenierung</a> verwendet:
</p>
<div class="mw-highlight mw-highlight-lang-text mw-content-ltr" dir="ltr"><pre><span></span> 42 + 3 (1)
3.14 + 1.0 (2)
"Hallo" + " Welt!" (3)
</pre></div>
<p>Einige <a href="Programmiersprache" title="Programmiersprache">Programmiersprachen</a> unterscheiden dabei, welche Namen <a href="%C3%9Cberladen" title="Überladen">überladen</a> werden dürfen und welche nicht. In <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> ist Methodenüberladung erlaubt, Operatorüberladung außer den schon eingebauten Überladungen wie der des +-Operators aber nicht. Auch in <a href="C-Sharp" title="C-Sharp">C#</a> sind nicht alle Operatoren überladbar. <a href="C%2B%2B" title="C++">C++</a> und manche andere Sprachen erlauben generell beides.
</p><p>Coercion ist eine Art implizite <a href="Typumwandlung" title="Typumwandlung">Typumwandlung</a>, sozusagen das Anwenden einer unsichtbaren, automatisch eingefügten Funktion, um zum Beispiel Argumente eines Unterprogramms oder einer Funktion in die erwarteten Typen umzuwandeln. Coercion ist mit dem Überladen eng verknüpft, und die Unterschiede sind für den Programmierer nicht unbedingt gleich ersichtlich.
</p><p>Beispiel:
</p>
<div class="mw-highlight mw-highlight-lang-text mw-content-ltr" dir="ltr"><pre><span></span> 3.14 + 2 (4)
3 + 2.14 (5)
</pre></div>
<p>In einer Sprache könnte der Additionsoperator lediglich für zwei reelle Zahlen definiert sein. Coercion würde dann dafür sorgen, dass <a href="Ganze_Zahl" title="Ganze Zahl">ganze Zahlen</a> zuerst in <a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkommazahlen</a> umgewandelt werden. In (4) und (5) würde dann Coercion zum Einsatz kommen. Es ist aber auch denkbar, dass der Additionsoperator für mehrere Varianten definiert ist.
</p><p>Bei der Überladung handelt es sich offenbar nicht um eine echte Form von Polymorphie, da man sich vorstellen könnte, der <a href="Compiler" title="Compiler">Compiler</a> werde die Uneindeutigkeit durch die mehrfache Benutzung eines Symboles zur Kompilationszeit wieder auflösen. Wir erlauben also nur einem Symbol, verschiedene (funktionsartige) Werte zu denotieren, die allerdings unterschiedliche und möglicherweise zueinander inkompatible Typen haben.
</p><p>Mit Coercions verhält es sich ähnlich. Man könnte meinen, ein <a href="Operator_(Mathematik)" title="Operator (Mathematik)">Operator</a> akzeptiere Operanden verschiedenen Typs (wie das + oben), jedoch müssen die Typen erst für den Operator gewandelt werden. Der Ausgabetyp des Operators hängt also nicht mehr mit den Typen der Operanden zusammen (oder nur partiell), daher kann keine echte Polymorphie vorliegen.
</p>
<div class="mw-heading mw-heading3"><h3 id="Parametrische_Polymorphie">Parametrische Polymorphie</h3></div>
<p>Parametrisierte Polymorphie repräsentiert Typen, deren Definitionen Typvariablen enthalten. In <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> spricht man auch von <a href="Generischer_Typ" title="Generischer Typ">generischen Typen</a> oder <span lang="en"><i>Generics</i></span>. Die meisten modernen objektorientierten Programmiersprachen unterstützen parametrische Typdefinitionen, darunter auch <a href="Strongtalk" title="Strongtalk">Strongtalk</a> (eine Variante von <a href="Smalltalk_(Programmiersprache)" title="Smalltalk (Programmiersprache)">Smalltalk</a> mit Typsystem), <a href="C-Sharp" title="C-Sharp">C#</a> oder <a href="Eiffel_(Programmiersprache)" title="Eiffel (Programmiersprache)">Eiffel</a>. In <a href="C%2B%2B" title="C++">C++</a> können generische Typen mit Hilfe sogenannter <a href="Template_(Programmierung)" class="mw-redirect" title="Template (Programmierung)">Templates</a> nachgebildet werden.
</p><p><i>Beispiel:</i>
</p>
<ul><li>monomorph</li></ul>
<dl><dd><code>TYPE iContainer IS ARRAY OF INTEGER;</code></dd></dl>
<ul><li>polymorph durch Typvariable</li></ul>
<dl><dd><code>TYPE Stack IS ARRAY OF [TYPVARIABLE]</code></dd></dl>
<div class="mw-heading mw-heading4"><h4 id="Beschränkter_parametrischer_Polymorphismus"><span id="Beschr.C3.A4nkter_parametrischer_Polymorphismus"></span>Beschränkter parametrischer Polymorphismus</h4></div>
<p>Man unterscheidet grundsätzlich
</p>
<ul><li>einfachen parametrischen Polymorphismus und</li>
<li>beschränkten parametrischen Polymorphismus.</li></ul>
<p>Letzterer behebt die Probleme der Typsicherheit, die innerhalb von Typdefinitionen dadurch entstehen, dass beim Erstellen der Typdefinition auf Grund der Parametrisierung noch nicht klar ist, Objekte welchen Typs eigentlich Gegenstand der Typ-Operationen (des Protokolls, der Methoden, die Terminologie variiert hier je nach Programmiersprache) sind. Wird durch einen Typ beispielsweise eine numerische Operation definiert, die auf den Elementen des Typs ausführbar sein soll, seine Typvariable dann aber mit einem nichtnumerischen Typen belegt, so würde es zu Laufzeitfehlern kommen. In der Regel verwendet man daher beschränkte parametrische Typen, die für ihre Typvariablen eine Beschränkung auf bestimmte Typen angeben. In Strongtalk wird hierzu bspw. die Typvariable mittels <i>T < Supertyp</i> angegeben, wobei Supertyp die Einschränkung der Typen angibt, die in die Typvariable T eingesetzt werden können. Java ermöglicht die Angabe solcher Einschränkungen mittels der Schreibweise <i><T extends Supertyp></i>. In C# gibt es verschiedene Arten von Einschränkungen ("Constraints"), die man für einen Typparameter verlangen kann: Abgeleitet von einer bestimmten Basisklasse, Vorhandensein eines bestimmten Interfaces oder eines parameterlosen Konstruktors sowie weitere. Kombinationen mehrerer Constraints sind möglich, die dann alle erfüllt sein müssen.
</p>
<div class="mw-heading mw-heading3"><h3 id="Inklusionspolymorphie">Inklusionspolymorphie</h3></div>
<p>Inklusionspolymorphie bezeichnet die Eigenschaft, jede Methode statt auf einem Subtyp auch auf einem Basistypen ausführen zu können. Subtyping ist demnach eine Form der Inklusionspolymorphie.
</p><p>Man unterscheidet zwischen:
</p>
<ul><li>Kompilationszeit-Polymorphie (statisches Binden)
<dl><dd>Es kann zur Kompilationszeit der Typ des Objekts und somit die aufgerufene Funktion (auch „Methode“ genannt) bestimmt werden.</dd></dl></li></ul>
<ul><li>Laufzeit-Polymorphie (<a href="Dynamisches_Binden" class="mw-redirect" title="Dynamisches Binden">dynamisches Binden</a>).
<dl><dd>Erst zur <a href="Laufzeit_(Informatik)" title="Laufzeit (Informatik)">Laufzeit</a> kann bestimmt werden, welche Methode aufzurufen ist (<i>späte Bindung</i>). Es kann also vom Programmlauf abhängig sein, welche Methode zur Anwendung kommt. Die Laufzeit-Polymorphie ist einer der wichtigsten Bestandteile der <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientierten Programmierung</a> und wurde zuerst in der Programmiersprache <a href="Smalltalk_(Programmiersprache)" title="Smalltalk (Programmiersprache)">Smalltalk</a> umgesetzt und zum Beispiel in <a href="Objective-C" title="Objective-C">Objective-C</a> eingesetzt. Ein weiteres Beispiel für <i>späte Bindung</i> sind <i>generische Methoden</i> wie im <a href="Common_Lisp_Object_System" title="Common Lisp Object System">Common Lisp Object System</a>.</dd></dl></li></ul>
<div class="mw-heading mw-heading4"><h4 id="Beispiele">Beispiele</h4></div>
<p>Angenommen, eine Anwendung soll statistische Daten sowohl grafisch als auch schriftlich in Tabellenform darstellen. Außerdem soll es möglich sein, die Darstellungsmethoden über <a href="Plug-in" title="Plug-in">Plug-ins</a> zu erweitern. Dann erlaubt das Konzept der Polymorphie über das <i>VisualizationPlugin</i> Interface jede beliebige Implementierung (hier <i>GraphDisplayPlugin</i>, <i>TextDisplayPlugin</i>, <i>HistogramDisplayPlugin</i>) aufzurufen.
</p><p>Die Anwendung selbst muss bei neuen <a href="Plug-in" title="Plug-in">Plug-ins</a> nicht geändert werden und kann diese einfach über das <a href="Schnittstelle_(Objektorientierung)" title="Schnittstelle (Objektorientierung)">Interface</a> mit dem Aufruf von <i>setData</i> und <i>display</i> starten.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="kd">interface</span> <span class="nc">VisualizationPlugin</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setData</span><span class="p">(</span><span class="n">DisplayData</span><span class="w"> </span><span class="n">data</span><span class="p">);</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">display</span><span class="p">();</span>
<span class="p">}</span>
<span class="kd">class</span> <span class="nc">GraphDisplayPlugin</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">VisualizationPlugin</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setData</span><span class="p">(</span><span class="n">DisplayData</span><span class="w"> </span><span class="n">data</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* set data to be displayed */</span><span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">display</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* Show Data as Graph */</span><span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
<span class="kd">class</span> <span class="nc">TextDisplayPlugin</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">VisualizationPlugin</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setData</span><span class="p">(</span><span class="n">DisplayData</span><span class="w"> </span><span class="n">data</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* set data to be displayed */</span><span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">display</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* Show Data as table */</span><span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
<span class="kd">class</span> <span class="nc">HistogramDisplayPlugin</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">VisualizationPlugin</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setData</span><span class="p">(</span><span class="n">DisplayData</span><span class="w"> </span><span class="n">data</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* set data and calculate history data */</span><span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">display</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="cm">/* Show history data as Graph */</span><span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div><p>Das folgende Beispiel in der <a href="Programmiersprache" title="Programmiersprache">Programmiersprache</a> <a href="C-Sharp" title="C-Sharp">C#</a> zeigt Subtyping für die <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methode</a> <i>berechneFlaecheninhalt()</i>. Die <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klassen</a> <i>Rechteck</i> und <i>Dreieck</i> implementieren die Methode, die das <a href="Interface" class="mw-redirect" title="Interface">Interface</a> <i>Polygon</i> deklariert. Die Methode <i>gibFlaecheninhalt(Polygon polygon)</i> kann die Implementierung der Methode <i>berechneFlaecheninhalt()</i> für jeden Subtyp des Interface <i>Polygon</i> (siehe <a href="Abgeleitete_Klasse" title="Abgeleitete Klasse">abgeleitete Klasse</a>) aufrufen.</p><div class="mw-highlight mw-highlight-lang-c# mw-content-ltr" dir="ltr"><pre><span></span><span class="k">public</span><span class="w"> </span><span class="k">interface</span><span class="w"> </span><span class="n">Polygon</span>
<span class="p">{</span>
<span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">berechneFlaecheninhalt</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">public</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="nc">Rechteck</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">Polygon</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">private</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">breite</span><span class="p">,</span><span class="w"> </span><span class="n">hoehe</span><span class="p">;</span>
<span class="w"> </span>
<span class="w"> </span><span class="c1">// Konstruktor</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="nf">Rechteck</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">breite</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">hoehe</span><span class="p">)</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="n">breite</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">breite</span><span class="p">;</span>
<span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="n">hoehe</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hoehe</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">berechneFlaecheninhalt</span><span class="p">()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">breite</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">hoehe</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="nc">Dreieck</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">Polygon</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">private</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">,</span><span class="w"> </span><span class="n">c</span><span class="p">;</span>
<span class="w"> </span>
<span class="w"> </span><span class="c1">// Konstruktor</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="nf">Dreieck</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">b</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">c</span><span class="p">)</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="n">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">a</span><span class="p">;</span>
<span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="n">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">b</span><span class="p">;</span>
<span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="n">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">c</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">berechneFlaecheninhalt</span><span class="p">()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Formel des Heron für den Flächeninhalt des allgemeinen Dreiecks</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mf">0.25</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Math</span><span class="p">.</span><span class="n">Sqrt</span><span class="p">((</span><span class="n">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">c</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="p">(</span><span class="o">-</span><span class="n">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">c</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">c</span><span class="p">)</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">c</span><span class="p">));</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
<span class="k">public</span><span class="w"> </span><span class="k">static</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">gibFlaecheninhalt</span><span class="p">(</span><span class="n">Polygon</span><span class="w"> </span><span class="n">polygon</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">polygon</span><span class="p">.</span><span class="n">berechneFlaecheninhalt</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">public</span><span class="w"> </span><span class="k">static</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">flaecheninhalt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">gibFlaecheninhalt</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Rechteck</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span><span class="w"> </span><span class="mi">16</span><span class="p">));</span><span class="w"> </span><span class="c1">// flaecheninhalt = 192</span>
<span class="w"> </span><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Das Rechteck hat den Flächeninhalt "</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">flaecheninhalt</span><span class="p">);</span>
<span class="w"> </span>
<span class="w"> </span><span class="n">flaecheninhalt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">gibFlaecheninhalt</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Dreieck</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">13</span><span class="p">,</span><span class="w"> </span><span class="mi">15</span><span class="p">));</span><span class="w"> </span><span class="c1">// flaecheninhalt = 24</span>
<span class="w"> </span><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Das Dreieck hat den Flächeninhalt "</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">flaecheninhalt</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Siehe_auch">Siehe auch</h2></div>
<ul><li><a href="Dynamische_Bindung" title="Dynamische Bindung">Dynamische Bindung</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>
<ul><li>Luca Cardelli, Peter Wegner: <a rel="nofollow" class="external text" href="http://citeseer.ist.psu.edu/cardelli85understanding.html"><i>On Understanding Types, Data Abstraction, and Polymorphism.</i></a> In: <i>ACM Computing Surveys.</i> 4/17/1985. ACM Press, New York/NY, S. 471–522, <span class="-print"><a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a> <span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%220360-0300%22&key=cql">0360-0300</a></span></span> <a href="https://doi.org/10.1145/6041.6042" class="extiw external" title="doi:10.1145/6041.6042">doi:10.1145/6041.6042</a>.</li>
<li>Thomas Letschert, FH Giessen-Friedberg – <style data-mw-deduplicate="TemplateStyles:r261891140">
/* start https://de.wikipedia.org/ */
.mw-parser-output .webarchiv-memento a{color:inherit}
/* end https://de.wikipedia.org/ */
</style><a rel="nofollow" class="external text" href="https://web.archive.org/web/20050802082135/http://velociraptor.mni.fh-giessen.de/Programmierung/ProgII-htmldir/node9.html">Polymorphismus</a> (<span class="webarchiv-memento"><a href="Webarchivierung#Begrifflichkeiten" title="Webarchivierung">Memento</a></span> vom 2. August 2005 im <i><a href="Internet_Archive" title="Internet Archive">Internet Archive</a></i>)</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>
<ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><a href="#cite_ref-1">↑</a></span> <span class="reference-text"><i>Informatik.</i> In: <i>Duden.</i> Mannheim 2001, ISBN 978-3-411-10023-1, S. 496.</span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><a href="#cite_ref-2">↑</a></span> <span class="reference-text"><i>Fundamental concepts in programming languages.</i> Lecture notes for International Summer School in Computer Programming, Copenhagen, August 1967.</span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><a href="#cite_ref-3">↑</a></span> <span class="reference-text"><i>On Understanding Types, Data Abstraction, and Polymorphism.</i> In: <i>ACM Computing Surveys.</i> Band 17, Nr. 4, 1985, S. 471–522.</span>
</li>
</ol></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2024-09-01" href="https://de.wikipedia.org/wiki/?title=Polymorphie_(Programmierung)&oldid=248232695">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>
</body></html>